home *** CD-ROM | disk | FTP | other *** search
/ IRIX Base Documentation 2002 November / SGI IRIX Base Documentation 2002 November.iso / usr / share / catman / u_man / cat1 / cvperf.z / cvperf
Encoding:
Text File  |  2002-10-03  |  9.8 KB  |  264 lines
  1.  
  2.  
  3.  
  4. CCCCVVVVPPPPEEEERRRRFFFF((((1111))))                                                            CCCCVVVVPPPPEEEERRRRFFFF((((1111))))
  5.  
  6.  
  7.  
  8. NNNNAAAAMMMMEEEE
  9.      cvperf - WorkShop Performance View
  10.  
  11. SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
  12.      ccccvvvvppppeeeerrrrffff {<experiment-record> | <pixie-counts-file>}
  13.  
  14. DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
  15.      _c_v_p_e_r_f presents a graphical display of the performance data gathered in a
  16.      WorkShop Performance experiment whose experiment directory is given by
  17.      <experiment-record>.
  18.  
  19.      _c_v_p_e_r_f can also present the display of performance information from a
  20.      _p_i_x_i_e counts file given by <pixie-counts-file>.  To use this feature, you
  21.      will need to install a patch with a later version of _p_i_x_i_e than is on the
  22.      current released system.  Contact Customer Support to obtain the patch.
  23.  
  24. EEEEXXXXPPPPEEEERRRRIIIIMMMMEEEENNNNTTTT TTTTYYYYPPPPEEEESSSS
  25.      The WorkShop Performance tools can record a number of different
  26.      experiments, each of which provides one or more metrics of performance.
  27.      Each has its strengths and weaknesses;  the experiment types are
  28.      described in the _C_A_S_E_V_i_s_i_o_n/_W_o_r_k_S_h_o_p _U_s_e_r'_s _G_u_i_d_e, and are briefly
  29.      described below.
  30.  
  31.      A ``Bottleneck'' experiment measures the performance of the program by
  32.      sampling the active process' callstack every 100 milliseconds, and using
  33.      the callstack data to attribute exclusive total time to the function at
  34.      the bottom of each callstack (_i._e., the function being executed at the
  35.      time of the sample), and to attribute inclusive total time to all the
  36.      functions above the one currently being executed.  In addition, this
  37.      experiment takes a caliper-sample every second, so that the user can
  38.      examine the data for any interval of execution.
  39.  
  40.      A ``Total Time'' experiment uses the same statistical callstack sampling
  41.      to compute performance metrics, but does not take caliper-samples, except
  42.      as the user specifies them.
  43.  
  44.      A ``CPU Time'' experiment instruments the program to count function calls
  45.      (both direct, and through function pointers), as well as do statistical
  46.      PC sampling on the resultant instrumented executable.  The PC sample data
  47.      is used to compute exclusive CPU time for each function, and the call
  48.      information is used to propagate the exclusive time to the callers of
  49.      each routine.
  50.  
  51.      An ``Ideal Time'' experiment generates the same data as a a pixie-fied
  52.      executable.  It instruments the program to maintain precise basic block
  53.      counts, and uses a machine model to convert the block execution counts
  54.      into an idealized exclusive time.  This time will be less than the real
  55.      time that any run would take, as it excludes any pipeline delays across
  56.      basic blocks, and does not take any cache or memory latencies into
  57.      account.  Inclusive time is propagated to callers based on the call
  58.      information, just as it is for ``CPU Time'' experiments.
  59.  
  60.  
  61.  
  62.  
  63.                                                                         PPPPaaaaggggeeee 1111
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70. CCCCVVVVPPPPEEEERRRRFFFF((((1111))))                                                            CCCCVVVVPPPPEEEERRRRFFFF((((1111))))
  71.  
  72.  
  73.  
  74.      An ``I/O Trace'' experiment traces each of the I/O calls made by the
  75.      executable, and computes inclusive and exclusive read and write counts,
  76.      and can show a time-based event chart for all calls with a given file-
  77.      descriptor.
  78.  
  79.      A ``System Call Trace'' experiment traces all calls, and can show a
  80.      time-based event chart for all calls, as well as compute read and write
  81.      counts.  This experiment is a super-set of the ``I/O Trace'' experiment.
  82.  
  83.      A ``Page Fault Trace'' experiment computes inclusive and exclusive page
  84.      fault counts, and also shows an event line with the time-based sequence
  85.      of page faults.
  86.  
  87.      A ``Find Memory Leaks'' experiment traces all calls to _m_a_l_l_o_c, _f_r_e_e,
  88.      etc., and computes inclusive and exclusive memory allocations and leaks,
  89.      and will also show any errors in calling these routines.  For more
  90.      information, see the malloc_cv(3) man page for more information.
  91.  
  92.      A ``Floating Point Exception'' trace experiment traces all such
  93.      exceptions, and computes inclusive and exclusive counts of these
  94.      exceptions, as well as an event line showing the time sequence of the
  95.      exceptions.
  96.  
  97.      A ``PC Sampling Time'' experiment uses a statistical counting of where
  98.      the process PC is as a function of time, and computes exclusive time from
  99.      that data.  There is no information in the data that allows computing of
  100.      inclusive times.
  101.  
  102.      A ``Custom Task'' can be run by choosing the particular instrumentation
  103.      and data desired.  Its use is discouraged, because not all combinations
  104.      will give meaningful results.  If there is a custom task that you desire,
  105.      please tell us, and we will endeavor to make a standard one for it.
  106.  
  107. UUUUSSSSEEEERRRR IIIINNNNTTTTEEEERRRRFFFFAAAACCCCEEEE
  108.      The Performance Analyzer main window has a Task component, a Function
  109.      List component, a per thread User Time/System Time State Chart component,
  110.      and a TimeLine component.
  111.  
  112.      The Task Component- simply states the task or objective that the user
  113.      selected for this experiment.
  114.  
  115.      The Function List Component- is an annotated list of all the functions in
  116.      the program. The annotations available depend on the experiment task;
  117.      annotations can be enabled or disabled by bringing up the Preferences
  118.      Dialog from the Config menu.
  119.  
  120.      The State Chart Component- allows the user to quickly guess at the
  121.      bottleneck resources in the different phases of the run, and also to see
  122.      thread balance information.  For some experiments, the State Chart is
  123.      replaced by an event line for the primary events being traced.  For
  124.      ``Find Memory Leaks'' experiment, it is replaced by a plot of process
  125.      address space and resident size as a function of time.
  126.  
  127.  
  128.  
  129.                                                                         PPPPaaaaggggeeee 2222
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136. CCCCVVVVPPPPEEEERRRRFFFF((((1111))))                                                            CCCCVVVVPPPPEEEERRRRFFFF((((1111))))
  137.  
  138.  
  139.  
  140.      The TimeLine Component- displays the experiment as a set of events over
  141.      time, and provides calipers to allow the user to specify an interval of
  142.      interest.
  143.  
  144.      There are also a number additional views, some of which are applicable to
  145.      all experiments, and some of which are meaningful only for some
  146.      experiment types.  The additional views are:
  147.  
  148.      Usage View (Graphs)- presents a graphical display of the process resource
  149.      usage data in the form of stripcharts and event charts.
  150.  
  151.      Usage View (Numerical)- presents a textual display of the process and
  152.      system wide resource usage data.
  153.  
  154.      IO View- presents a per file descriptor chart of the number of bytes
  155.      transferred.  This view is available only for I/O tracing or System call
  156.      tracing experiments.
  157.  
  158.      Call Graph View- presents the target program as nodes and arcs.
  159.  
  160.      Butterfly View- shows the caller and callee relationships for any
  161.      selected function.
  162.  
  163.      Leak View- presents a list of all of the memory leaks in the target
  164.      program.  A leak is any region that is _m_a_l_l_o_c'd, but not _f_r_e_e'd.  The
  165.      leaks are aggregated by common callstack.  This view is available only
  166.      for Memory Leak experiments.
  167.  
  168.      Malloc View- presents a list of all of the memory allocation in the
  169.      target program, aggregated by common callstack.  This view is available
  170.      only for Memory Leak experiments.
  171.  
  172.      Malloc Error View- presents a list of all of the memory allocation errors
  173.      in the target program, aggregated by common callstack.  This view is
  174.      available only for Memory Leak experiments.
  175.  
  176.      Heap View- presents a graphical display of use of the heap by the target
  177.      program.  This view is available only for Memory Leak experiments.
  178.  
  179.      Call Stack View- presents the callstack at the event currently selected
  180.      in the TimeLine component, or in any event chart for tracing experiments.
  181.  
  182.      Working Set View- presents a list of all of the DSO's in the program,
  183.      with information on the efficiency of use of the text (instruction)
  184.      pages.  This view is available only for Ideal time experiments.
  185.  
  186.      Source View- presents an annotated Source View, and is brought up by
  187.      double clicking on any function in the function list, on any node in the
  188.      Call Graph View, or on any frame in the Call Stack View.  If _c_v_p_e_r_f is
  189.      being run in a session with the debugger, _c_v_d, also running, the
  190.      annotations will appear in the debugger's main source window.  If there
  191.      is no debugger window running, a separate Source View will be used.
  192.  
  193.  
  194.  
  195.                                                                         PPPPaaaaggggeeee 3333
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202. CCCCVVVVPPPPEEEERRRRFFFF((((1111))))                                                            CCCCVVVVPPPPEEEERRRRFFFF((((1111))))
  203.  
  204.  
  205.  
  206.      Disassembly View- presents an annotated Disassembled View of the
  207.      currently selected function.
  208.  
  209. SSSSEEEEEEEE AAAALLLLSSSSOOOO
  210.      cvd(1), cvmeter(1), on-line help for cvperf.
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.  
  224.  
  225.  
  226.  
  227.  
  228.  
  229.  
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238.  
  239.  
  240.  
  241.  
  242.  
  243.  
  244.  
  245.  
  246.  
  247.  
  248.  
  249.  
  250.  
  251.  
  252.  
  253.  
  254.  
  255.  
  256.  
  258.  
  259.  
  260.                                                                         PPPPaaaaggggeeee 4444
  261.  
  262.  
  263.  
  264.